Solution-Relevant Abstractions Constrain Retrieval and Adaptation

A second problem in analogical reasoning, addressed for instance by Holyoak [7] and Gentner [5], is to choose from a variety of possible analogical mappings. As we shall show, solution-relevant abstractions can be exploited for this task as well. A third non-trivial job in the analogy procedure is to determine the reformulations (adaptations) of problems and solutions. To some extent the proofrelevant abstractions can also be employed to trigger reformulations. In this paper, we shall present semantic, solution-relevant abstractions in inductive theorem proving that can be found automatically and the preservation of which guarantees a successful transfer of large parts of the proofs. We shall not go into details of the implemented analogy, but the paper focuses on the use of the abstractions for restricting the retrieval and the problem mapping. As we shall see, these abstractions can also serve to determine certain reformulations of the source solution that go beyond an adaptation by symbol mapping. 2 Proof Planning for Proofs by Induction A proof plan is an abstract representation of a proof that consists of trees of method nodes which are connected by sequents, called goals. The proof planner CLAM [3] has been applied successfully to inductive theorem proving because it knows patterns of inductive proofs consisting of base-cases and step-case and it employs a strong search heuristic, called rippling. The major aim of the step-case proof is to rewrite the induction conclusion until the induction hypothesis is applicable, i.e., to reduce the di erences between the induction conclusion and the induction hypothesis. To that end, rippling involves annotating the induction conclusion with wave fronts and wave holes: Wave fronts mark the di erences between induction hypothesis and conclusion. Waves annotate the smallest terms containing wave-fronts.Wave holes represent the parts of waves that also appear in the induction hypothesis. For example, in planning the theorem lenapp: 8a; b: length(app(a; b)) = length(app(b; a)) (1) the induction hypothesis is length(app(a; b)) = length(app(b; a)) (2) and the annotated induction conclusion is length(app( cons(h; a) ; b)) = length(app(b; cons(h; a) )) (3) where cons; app are the usual functions on lists. The boxes denote the waves. Wave holes are underlined and wave fronts are the non-underlined parts within the boxes. The skeleton of an annotated term is constructed from wave holes and the parts of the term that do not belong to a wave. Rippling also annotates2 rewrite rules such that the skeleton of the LHS equals the skeleton of the RHS. The resulting skeleton preserving rules are called wave-rules. E.g., a wave-rule for the function app, computed from de ning rules of app, is app( (cons(X;Y )) ; Z)) cons(X; (app(Y; Z))) : (4) The skeleton on each side of the implication is app(Y; Z). Rippling works by systematically applying wave-rules to the induction conclusion and to subgoals in the plan. By applying wave-rules to successive goals in the planning process, wave fronts can be moved or removed. In this way, rippling works towards its goal of moving or removing those parts of the induction conclusion which are marked by the wave fronts, so that the induction hypothesis, represented by the skeleton, can be used. You can imagine that the wave fronts move through the term tree of the theorem when a wave-rule is applied. For instance, if (4) and another rule are applied to the goal (3) the following subgoal is obtained: s(length(app(a; b))) = length(app(b; cons(h; a) )) (5) For a visualization of rippling see Figure 1. Note how the wave front on the LHS has been moved outwards from the term tree of (3) to the term tree of (5). h a b = b a h = b a h s a b length length length length append append append append cons cons cons Fig. 1. Term tree of (3) changes to term tree of (5), rippling path in bold 3 Abstractions that Guide the Transfer of Proofs Remember that one of the main problems for analogical reasoning is to recognize features of problems which ensure the similarity of their respective solutions in order to be able to retrieve useful sources and which allow for the choice of appropriate mappings from a possibly large set of (second-order3)-mappings between source and target problems. We present a solution for this problem in analogy-driven proof plan construction for inductive theorem proving that employs proof-relevant abstractions. 2 The annotations being the wave fronts and wave holes 3 second-order mapping means that function symbols are mapped to function terms. 3.1 Analogy-driven Proof Plan Construction The analogy-driven proof plan construction introduced in [11] is a control strategy of a proof planner that suggests methods and instantiations rather than searching for them. This analogy comprises retrieval, mapping, reformulation, and replay. The reformulations that yield changes of the theorem and proof assumptions that are accompanied by certain changes of the proof plan. The analogy-driven proof plan construction has been implemented on top of the proof planner CLAM . The resulting analogical transfer for the example stepcase of the lenapp proof to a proof of halfplus is shown in Figure 2, where length is abbreviated by len, app by in x <>, cons by ::. The retrieval based on proof-relevant abstractions is explained in section 4. SOURCE PLAN len( :: (h; a) <> b) = len(b <> :: (h; a) ) ????y wave(app2) ????y len( :: (h; (a <> b)) ) = len(b <> :: (h; a) ) ????y wave(len2) s(len(a <> b) = len(b <> :: (h; a) ) ????y wave(lenapp2) s(len(a <> b) = s(len(b <> a) ????y fertilize s(len(b <> a) = s(len(b <> a) ????y elementary true TARGET PLAN half( s(s(a)) + b) = half(b+ s(s(a)) ) ????y wave(plus2) half( s( s(a) + b) ) = half(b+ s(s(a)) ) ????y wave(plus2) half( s( s(a+ b) ) ) = half(b+ s(s(a)) ) ????y wave(half3) s(half(a+ b)) = half(b+ s(s(a)) ) ????y wave(lemma) s(half(a+ b)) = s(half(b+ a)) ????y fertilize s(half(b+ a)) = s(half(b+ a)) ????y elementary true Fig. 2. Step-case replay Before the actual analogical replay, second-order mappings from the source theorem and wave-rules to the target theorem and wave-rules are found guided by proof-relevant abstractions as explained in section 5. An analysis of these mappings and of their result w.r.t. changing proof-relevant abstractions decides which reformulations to be applied. This is described in section 6. Note that the abstraction is used at a meta-level. This means that rather than taking the proof/plan of an abstracted problem as the source solution to be replayed and adapted, we use abstract features of the source and target problems to restrict the retrieval, mapping, and to trigger reformulations. 3.2 The Labelled Fragment Abstraction Labelled fragments(LFs), introduced in [8], are an abstraction of wave-rules obtained by removing the structure of the wave-fronts and those parts of the skeleton not a ected by wave-fronts. For each function/relation symbol occurring in the source and target theorem we automatically compute labelled fragments corresponding to wave-rules that belong to the source and target problem, respectively. Take, for instance, the wave-rule app2 app( cons(X;Y ) ; Z)) cons(X; (app(Y; Z))) : Note that in the lhs of app2 the wave-front is situated at the left( rst) argument of app and how it moves to the top of app in the rhs of app2. This situation is re ected in the most right labelled fragment of app as shown in Figure 3. The wave-rule len2 length( cons(X;Y ) )) s(length(Y )) is abstractly encoded into the labelled fragment of length. half length lenght half app + + app Fig. 3. Labelled fragments As we shall see, the labelled fragment abstractions are semantically motivated by the course of inductive theorem proving that employs rippling, rather than purely syntactically motivated by symbol matching. In the following, we substantiate why labelled fragments are proof-relevant abstractions and explain how they are used by our analogy procedure. 4 How the Retrieval Employs Labelled Fragments The term tree of a theorem is called the theorem tree. The rippling paths, as shown in Figure 4, are the paths in the theorem tree on which the wave-fronts are moved successfully by rippling. The LFs of functions/relations in a theorem tree determine the rippling paths through the theorem tree. This can be seen in Figure 4, where the bold rippling paths start at the induction variables and are combined from LFs of Figure 3. Note how the rippling paths of lenapp and halfplus agree because the LFs of app and + and of length and half agree.